home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1998 January: Mac OS SDK / Dev.CD Jan 98 SDK1.toast / Development Kits (Disc 1) / Interfaces&Libraries / Universal / Interfaces / PInterfaces / Quickdraw.p < prev    next >
Encoding:
Text File  |  1997-08-12  |  61.4 KB  |  1,847 lines  |  [TEXT/MPS ]
  1. {
  2.      File:        Quickdraw.p
  3.  
  4.      Contains:    Quickdraw Graphics Interfaces.
  5.  
  6.      Version:    Technology:    System 7.5
  7.                  Release:    Universal Interfaces 3.0.1
  8.  
  9.      Copyright:    © 1985-1997 by Apple Computer, Inc., all rights reserved
  10.  
  11.      Bugs?:        Please include the the file and version information (from above) with
  12.                  the problem description.  Developers belonging to one of the Apple
  13.                  developer programs can submit bug reports to:
  14.  
  15.                      devsupport@apple.com
  16.  
  17. }
  18. {$IFC UNDEFINED UsingIncludes}
  19. {$SETC UsingIncludes := 0}
  20. {$ENDC}
  21.  
  22. {$IFC NOT UsingIncludes}
  23.  UNIT Quickdraw;
  24.  INTERFACE
  25. {$ENDC}
  26.  
  27. {$IFC UNDEFINED __QUICKDRAW__}
  28. {$SETC __QUICKDRAW__ := 1}
  29.  
  30. {$I+}
  31. {$SETC QuickdrawIncludes := UsingIncludes}
  32. {$SETC UsingIncludes := 1}
  33.  
  34. {$IFC UNDEFINED __TYPES__}
  35. {$I Types.p}
  36. {$ENDC}
  37. {$IFC UNDEFINED __MIXEDMODE__}
  38. {$I MixedMode.p}
  39. {$ENDC}
  40. {$IFC UNDEFINED __QUICKDRAWTEXT__}
  41. {$I QuickdrawText.p}
  42. {$ENDC}
  43.  
  44.  
  45. {$PUSH}
  46. {$ALIGN MAC68K}
  47. {$LibExport+}
  48.  
  49.  
  50. CONST
  51.     invalColReq                    = -1;                            { invalid color table request }
  52.                                                                 {  transfer modes  }
  53.     srcCopy                        = 0;                            { the 16 transfer modes }
  54.     srcOr                        = 1;
  55.     srcXor                        = 2;
  56.     srcBic                        = 3;
  57.     notSrcCopy                    = 4;
  58.     notSrcOr                    = 5;
  59.     notSrcXor                    = 6;
  60.     notSrcBic                    = 7;
  61.     patCopy                        = 8;
  62.     patOr                        = 9;
  63.     patXor                        = 10;
  64.     patBic                        = 11;
  65.     notPatCopy                    = 12;
  66.     notPatOr                    = 13;
  67.     notPatXor                    = 14;
  68.     notPatBic                    = 15;                            {  Special Text Transfer Mode  }
  69.     grayishTextOr                = 49;
  70.     hilitetransfermode            = 50;
  71.     hilite                        = 50;                            {  Arithmetic transfer modes  }
  72.     blend                        = 32;
  73.     addPin                        = 33;
  74.     addOver                        = 34;
  75.     subPin                        = 35;
  76.     addMax                        = 37;
  77.     adMax                        = 37;
  78.     subOver                        = 38;
  79.     adMin                        = 39;
  80.     ditherCopy                    = 64;                            {  Transparent mode constant  }
  81.     transparent                    = 36;
  82.  
  83.     italicBit                    = 1;
  84.     ulineBit                    = 2;
  85.     outlineBit                    = 3;
  86.     shadowBit                    = 4;
  87.     condenseBit                    = 5;
  88.     extendBit                    = 6;                            {  QuickDraw color separation constants  }
  89.     normalBit                    = 0;                            { normal screen mapping }
  90.     inverseBit                    = 1;                            { inverse screen mapping }
  91.     redBit                        = 4;                            { RGB additive mapping }
  92.     greenBit                    = 3;
  93.     blueBit                        = 2;
  94.     cyanBit                        = 8;                            { CMYBk subtractive mapping }
  95.     magentaBit                    = 7;
  96.     yellowBit                    = 6;
  97.     blackBit                    = 5;
  98.  
  99.     blackColor                    = 33;                            { colors expressed in these mappings }
  100.     whiteColor                    = 30;
  101.     redColor                    = 205;
  102.     greenColor                    = 341;
  103.     blueColor                    = 409;
  104.     cyanColor                    = 273;
  105.     magentaColor                = 137;
  106.     yellowColor                    = 69;
  107.  
  108.     picLParen                    = 0;                            { standard picture comments }
  109.     picRParen                    = 1;
  110.     clutType                    = 0;                            { 0 if lookup table }
  111.     fixedType                    = 1;                            { 1 if fixed table }
  112.     directType                    = 2;                            { 2 if direct values }
  113.     gdDevType                    = 0;                            { 0 = monochrome 1 = color }
  114.  
  115.     interlacedDevice            = 2;                            {  1 if single pixel lines look bad  }
  116.     roundedDevice                = 5;                            {  1 if device has been “rounded” into the GrayRgn  }
  117.     hasAuxMenuBar                = 6;                            {  1 if device has an aux menu bar on it  }
  118.     burstDevice                    = 7;
  119.     ext32Device                    = 8;
  120.     ramInit                        = 10;                            { 1 if initialized from 'scrn' resource }
  121.     mainScreen                    = 11;                            {  1 if main screen  }
  122.     allInit                        = 12;                            {  1 if all devices initialized  }
  123.     screenDevice                = 13;                            { 1 if screen device [not used] }
  124.     noDriver                    = 14;                            {  1 if no driver for this GDevice  }
  125.     screenActive                = 15;                            { 1 if in use }
  126.     hiliteBit                    = 7;                            { flag bit in HiliteMode (lowMem flag) }
  127.     pHiliteBit                    = 0;                            { flag bit in HiliteMode used with BitClr procedure }
  128.     defQDColors                    = 127;                            { resource ID of clut for default QDColors }
  129.                                                                 {  pixel type  }
  130.     RGBDirect                    = 16;                            {  16 & 32 bits/pixel pixelType value  }
  131.                                                                 {  pmVersion values  }
  132.     baseAddr32                    = 4;                            { pixmap base address is 32-bit address }
  133.  
  134.  
  135.     sysPatListID                = 0;
  136.     iBeamCursor                    = 1;
  137.     crossCursor                    = 2;
  138.     plusCursor                    = 3;
  139.     watchCursor                    = 4;
  140.  
  141.     kQDGrafVerbFrame            = 0;
  142.     kQDGrafVerbPaint            = 1;
  143.     kQDGrafVerbErase            = 2;
  144.     kQDGrafVerbInvert            = 3;
  145.     kQDGrafVerbFill                = 4;
  146.  
  147. {$IFC OLDROUTINENAMES }
  148.     frame                        = 0;
  149.     paint                        = 1;
  150.     erase                        = 2;
  151.     invert                        = 3;
  152.     fill                        = 4;
  153.  
  154. {$ENDC}  {OLDROUTINENAMES}
  155.  
  156.  
  157. TYPE
  158.     GrafVerb                            = SInt8;
  159.  
  160. CONST
  161.     chunky                        = 0;
  162.     chunkyPlanar                = 1;
  163.     planar                        = 2;
  164.  
  165.  
  166. TYPE
  167.     PixelType                            = SInt8;
  168.     Bits16                                = ARRAY [0..15] OF INTEGER;
  169.  
  170. {**************   IMPORTANT NOTE REGARDING Pattern  **************************************
  171.    Patterns were originally defined as:
  172.    
  173.         C:             typedef unsigned char Pattern[8];
  174.         Pascal:        Pattern = PACKED ARRAY [0..7] OF 0..255;
  175.         
  176.    The old array defintion of Pattern would cause 68000 based CPU's to crash in certain circum-
  177.    stances. The new struct definition is safe, but may require source code changes to compile.
  178.    Read the details in TechNote "Platforms & Tools" #PT 38.
  179.     
  180. ********************************************************************************************}
  181.     PatternPtr = ^Pattern;
  182.     Pattern = RECORD
  183.         pat:                    PACKED ARRAY [0..7] OF UInt8;
  184.     END;
  185.  
  186. {
  187.  ConstPatternParam is now longer needed.  It was first created when Pattern was an array.
  188.  Now that Pattern is a struct, it is more straight forward just add the "const" qualifier
  189.  on the parameter type (e.g. "const Pattern * pat" instead of "ConstPatternParam pat").
  190. }
  191.     PatPtr                                = ^Pattern;
  192.     PatHandle                            = ^PatPtr;
  193.     QDByte                                = SignedByte;
  194.     QDPtr                                = Ptr;
  195.     QDHandle                            = Handle;
  196.     QDErr                                = INTEGER;
  197.  
  198. CONST
  199.     singleDevicesBit            = 0;
  200.     dontMatchSeedsBit            = 1;
  201.     allDevicesBit                = 2;
  202.  
  203.     singleDevices                = $01;
  204.     dontMatchSeeds                = $02;
  205.     allDevices                    = $04;
  206.  
  207.  
  208. TYPE
  209.     DeviceLoopFlags                        = LONGINT;
  210.     BitMapPtr = ^BitMap;
  211.     BitMap = RECORD
  212.         baseAddr:                Ptr;
  213.         rowBytes:                INTEGER;
  214.         bounds:                    Rect;
  215.     END;
  216.  
  217.     BitMapHandle                        = ^BitMapPtr;
  218.     CursorPtr = ^Cursor;
  219.     Cursor = RECORD
  220.         data:                    Bits16;
  221.         mask:                    Bits16;
  222.         hotSpot:                Point;
  223.     END;
  224.  
  225.     CursPtr                                = ^Cursor;
  226.     CursHandle                            = ^CursPtr;
  227.     PenStatePtr = ^PenState;
  228.     PenState = RECORD
  229.         pnLoc:                    Point;
  230.         pnSize:                    Point;
  231.         pnMode:                    INTEGER;
  232.         pnPat:                    Pattern;
  233.     END;
  234.  
  235.     RegionPtr = ^Region;
  236.     Region = RECORD
  237.         rgnSize:                INTEGER;                                { size in bytes }
  238.         rgnBBox:                Rect;                                    { enclosing rectangle }
  239.     END;
  240.  
  241.     RgnPtr                                = ^Region;
  242.     RgnHandle                            = ^RgnPtr;
  243.     PicturePtr = ^Picture;
  244.     Picture = RECORD
  245.         picSize:                INTEGER;
  246.         picFrame:                Rect;
  247.     END;
  248.  
  249.     PicPtr                                = ^Picture;
  250.     PicHandle                            = ^PicPtr;
  251.     PolygonPtr = ^Polygon;
  252.     Polygon = RECORD
  253.         polySize:                INTEGER;
  254.         polyBBox:                Rect;
  255.         polyPoints:                ARRAY [0..0] OF Point;
  256.     END;
  257.  
  258.     PolyPtr                                = ^Polygon;
  259.     PolyHandle                            = ^PolyPtr;
  260.     QDTextProcPtr = ProcPtr;  { PROCEDURE QDText(byteCount: INTEGER; textBuf: Ptr; numer: Point; denom: Point); }
  261.  
  262.     QDLineProcPtr = ProcPtr;  { PROCEDURE QDLine(newPt: Point); }
  263.  
  264.     QDRectProcPtr = ProcPtr;  { PROCEDURE QDRect(verb: GrafVerb; VAR r: Rect); }
  265.  
  266.     QDRRectProcPtr = ProcPtr;  { PROCEDURE QDRRect(verb: GrafVerb; VAR r: Rect; ovalWidth: INTEGER; ovalHeight: INTEGER); }
  267.  
  268.     QDOvalProcPtr = ProcPtr;  { PROCEDURE QDOval(verb: GrafVerb; VAR r: Rect); }
  269.  
  270.     QDArcProcPtr = ProcPtr;  { PROCEDURE QDArc(verb: GrafVerb; VAR r: Rect; startAngle: INTEGER; arcAngle: INTEGER); }
  271.  
  272.     QDPolyProcPtr = ProcPtr;  { PROCEDURE QDPoly(verb: GrafVerb; poly: PolyHandle); }
  273.  
  274.     QDRgnProcPtr = ProcPtr;  { PROCEDURE QDRgn(verb: GrafVerb; rgn: RgnHandle); }
  275.  
  276.     QDBitsProcPtr = ProcPtr;  { PROCEDURE QDBits(VAR srcBits: BitMap; VAR srcRect: Rect; VAR dstRect: Rect; mode: INTEGER; maskRgn: RgnHandle); }
  277.  
  278.     QDCommentProcPtr = ProcPtr;  { PROCEDURE QDComment(kind: INTEGER; dataSize: INTEGER; dataHandle: Handle); }
  279.  
  280.     QDTxMeasProcPtr = ProcPtr;  { FUNCTION QDTxMeas(byteCount: INTEGER; textAddr: Ptr; VAR numer: Point; VAR denom: Point; VAR info: FontInfo): INTEGER; }
  281.  
  282.     QDGetPicProcPtr = ProcPtr;  { PROCEDURE QDGetPic(dataPtr: Ptr; byteCount: INTEGER); }
  283.  
  284.     QDPutPicProcPtr = ProcPtr;  { PROCEDURE QDPutPic(dataPtr: Ptr; byteCount: INTEGER); }
  285.  
  286.     QDOpcodeProcPtr = ProcPtr;  { PROCEDURE QDOpcode(VAR fromRect: Rect; VAR toRect: Rect; opcode: INTEGER; version: INTEGER); }
  287.  
  288.     QDJShieldCursorProcPtr = ProcPtr;  { PROCEDURE QDJShieldCursor(left: INTEGER; top: INTEGER; right: INTEGER; bottom: INTEGER); }
  289.  
  290.     QDTextUPP = UniversalProcPtr;
  291.     QDLineUPP = UniversalProcPtr;
  292.     QDRectUPP = UniversalProcPtr;
  293.     QDRRectUPP = UniversalProcPtr;
  294.     QDOvalUPP = UniversalProcPtr;
  295.     QDArcUPP = UniversalProcPtr;
  296.     QDPolyUPP = UniversalProcPtr;
  297.     QDRgnUPP = UniversalProcPtr;
  298.     QDBitsUPP = UniversalProcPtr;
  299.     QDCommentUPP = UniversalProcPtr;
  300.     QDTxMeasUPP = UniversalProcPtr;
  301.     QDGetPicUPP = UniversalProcPtr;
  302.     QDPutPicUPP = UniversalProcPtr;
  303.     QDOpcodeUPP = UniversalProcPtr;
  304.     QDJShieldCursorUPP = UniversalProcPtr;
  305.     QDProcsPtr = ^QDProcs;
  306.     QDProcs = RECORD
  307.         textProc:                QDTextUPP;
  308.         lineProc:                QDLineUPP;
  309.         rectProc:                QDRectUPP;
  310.         rRectProc:                QDRRectUPP;
  311.         ovalProc:                QDOvalUPP;
  312.         arcProc:                QDArcUPP;
  313.         polyProc:                QDPolyUPP;
  314.         rgnProc:                QDRgnUPP;
  315.         bitsProc:                QDBitsUPP;
  316.         commentProc:            QDCommentUPP;
  317.         txMeasProc:                QDTxMeasUPP;
  318.         getPicProc:                QDGetPicUPP;
  319.         putPicProc:                QDPutPicUPP;
  320.     END;
  321.  
  322.  
  323. CONST
  324.     uppQDTextProcInfo = $00003F80;
  325.     uppQDLineProcInfo = $000000C0;
  326.     uppQDRectProcInfo = $00000340;
  327.     uppQDRRectProcInfo = $00002B40;
  328.     uppQDOvalProcInfo = $00000340;
  329.     uppQDArcProcInfo = $00002B40;
  330.     uppQDPolyProcInfo = $00000340;
  331.     uppQDRgnProcInfo = $00000340;
  332.     uppQDBitsProcInfo = $0000EFC0;
  333.     uppQDCommentProcInfo = $00000E80;
  334.     uppQDTxMeasProcInfo = $0000FFA0;
  335.     uppQDGetPicProcInfo = $000002C0;
  336.     uppQDPutPicProcInfo = $000002C0;
  337.     uppQDOpcodeProcInfo = $00002BC0;
  338.     uppQDJShieldCursorProcInfo = $00002A80;
  339.  
  340. FUNCTION NewQDTextProc(userRoutine: QDTextProcPtr): QDTextUPP;
  341.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  342.     INLINE $2E9F;
  343.     {$ENDC}
  344.  
  345. FUNCTION NewQDLineProc(userRoutine: QDLineProcPtr): QDLineUPP;
  346.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  347.     INLINE $2E9F;
  348.     {$ENDC}
  349.  
  350. FUNCTION NewQDRectProc(userRoutine: QDRectProcPtr): QDRectUPP;
  351.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  352.     INLINE $2E9F;
  353.     {$ENDC}
  354.  
  355. FUNCTION NewQDRRectProc(userRoutine: QDRRectProcPtr): QDRRectUPP;
  356.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  357.     INLINE $2E9F;
  358.     {$ENDC}
  359.  
  360. FUNCTION NewQDOvalProc(userRoutine: QDOvalProcPtr): QDOvalUPP;
  361.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  362.     INLINE $2E9F;
  363.     {$ENDC}
  364.  
  365. FUNCTION NewQDArcProc(userRoutine: QDArcProcPtr): QDArcUPP;
  366.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  367.     INLINE $2E9F;
  368.     {$ENDC}
  369.  
  370. FUNCTION NewQDPolyProc(userRoutine: QDPolyProcPtr): QDPolyUPP;
  371.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  372.     INLINE $2E9F;
  373.     {$ENDC}
  374.  
  375. FUNCTION NewQDRgnProc(userRoutine: QDRgnProcPtr): QDRgnUPP;
  376.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  377.     INLINE $2E9F;
  378.     {$ENDC}
  379.  
  380. FUNCTION NewQDBitsProc(userRoutine: QDBitsProcPtr): QDBitsUPP;
  381.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  382.     INLINE $2E9F;
  383.     {$ENDC}
  384.  
  385. FUNCTION NewQDCommentProc(userRoutine: QDCommentProcPtr): QDCommentUPP;
  386.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  387.     INLINE $2E9F;
  388.     {$ENDC}
  389.  
  390. FUNCTION NewQDTxMeasProc(userRoutine: QDTxMeasProcPtr): QDTxMeasUPP;
  391.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  392.     INLINE $2E9F;
  393.     {$ENDC}
  394.  
  395. FUNCTION NewQDGetPicProc(userRoutine: QDGetPicProcPtr): QDGetPicUPP;
  396.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  397.     INLINE $2E9F;
  398.     {$ENDC}
  399.  
  400. FUNCTION NewQDPutPicProc(userRoutine: QDPutPicProcPtr): QDPutPicUPP;
  401.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  402.     INLINE $2E9F;
  403.     {$ENDC}
  404.  
  405. FUNCTION NewQDOpcodeProc(userRoutine: QDOpcodeProcPtr): QDOpcodeUPP;
  406.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  407.     INLINE $2E9F;
  408.     {$ENDC}
  409.  
  410. FUNCTION NewQDJShieldCursorProc(userRoutine: QDJShieldCursorProcPtr): QDJShieldCursorUPP;
  411.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  412.     INLINE $2E9F;
  413.     {$ENDC}
  414.  
  415. PROCEDURE CallQDTextProc(byteCount: INTEGER; textBuf: Ptr; numer: Point; denom: Point; userRoutine: QDTextUPP);
  416.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  417.     INLINE $205F, $4E90;
  418.     {$ENDC}
  419.  
  420. PROCEDURE CallQDLineProc(newPt: Point; userRoutine: QDLineUPP);
  421.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  422.     INLINE $205F, $4E90;
  423.     {$ENDC}
  424.  
  425. PROCEDURE CallQDRectProc(verb: GrafVerb; VAR r: Rect; userRoutine: QDRectUPP);
  426.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  427.     INLINE $205F, $4E90;
  428.     {$ENDC}
  429.  
  430. PROCEDURE CallQDRRectProc(verb: GrafVerb; VAR r: Rect; ovalWidth: INTEGER; ovalHeight: INTEGER; userRoutine: QDRRectUPP);
  431.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  432.     INLINE $205F, $4E90;
  433.     {$ENDC}
  434.  
  435. PROCEDURE CallQDOvalProc(verb: GrafVerb; VAR r: Rect; userRoutine: QDOvalUPP);
  436.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  437.     INLINE $205F, $4E90;
  438.     {$ENDC}
  439.  
  440. PROCEDURE CallQDArcProc(verb: GrafVerb; VAR r: Rect; startAngle: INTEGER; arcAngle: INTEGER; userRoutine: QDArcUPP);
  441.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  442.     INLINE $205F, $4E90;
  443.     {$ENDC}
  444.  
  445. PROCEDURE CallQDPolyProc(verb: GrafVerb; poly: PolyHandle; userRoutine: QDPolyUPP);
  446.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  447.     INLINE $205F, $4E90;
  448.     {$ENDC}
  449.  
  450. PROCEDURE CallQDRgnProc(verb: GrafVerb; rgn: RgnHandle; userRoutine: QDRgnUPP);
  451.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  452.     INLINE $205F, $4E90;
  453.     {$ENDC}
  454.  
  455. PROCEDURE CallQDBitsProc(VAR srcBits: BitMap; VAR srcRect: Rect; VAR dstRect: Rect; mode: INTEGER; maskRgn: RgnHandle; userRoutine: QDBitsUPP);
  456.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  457.     INLINE $205F, $4E90;
  458.     {$ENDC}
  459.  
  460. PROCEDURE CallQDCommentProc(kind: INTEGER; dataSize: INTEGER; dataHandle: Handle; userRoutine: QDCommentUPP);
  461.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  462.     INLINE $205F, $4E90;
  463.     {$ENDC}
  464.  
  465. FUNCTION CallQDTxMeasProc(byteCount: INTEGER; textAddr: Ptr; VAR numer: Point; VAR denom: Point; VAR info: FontInfo; userRoutine: QDTxMeasUPP): INTEGER;
  466.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  467.     INLINE $205F, $4E90;
  468.     {$ENDC}
  469.  
  470. PROCEDURE CallQDGetPicProc(dataPtr: Ptr; byteCount: INTEGER; userRoutine: QDGetPicUPP);
  471.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  472.     INLINE $205F, $4E90;
  473.     {$ENDC}
  474.  
  475. PROCEDURE CallQDPutPicProc(dataPtr: Ptr; byteCount: INTEGER; userRoutine: QDPutPicUPP);
  476.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  477.     INLINE $205F, $4E90;
  478.     {$ENDC}
  479.  
  480. PROCEDURE CallQDOpcodeProc(VAR fromRect: Rect; VAR toRect: Rect; opcode: INTEGER; version: INTEGER; userRoutine: QDOpcodeUPP);
  481.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  482.     INLINE $205F, $4E90;
  483.     {$ENDC}
  484.  
  485. PROCEDURE CallQDJShieldCursorProc(left: INTEGER; top: INTEGER; right: INTEGER; bottom: INTEGER; userRoutine: QDJShieldCursorUPP);
  486.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  487.     INLINE $205F, $4E90;
  488.     {$ENDC}
  489.  
  490.  
  491.  
  492. TYPE
  493.     GrafPortPtr = ^GrafPort;
  494.     GrafPort = RECORD
  495.         device:                    INTEGER;
  496.         portBits:                BitMap;
  497.         portRect:                Rect;
  498.         visRgn:                    RgnHandle;
  499.         clipRgn:                RgnHandle;
  500.         bkPat:                    Pattern;
  501.         fillPat:                Pattern;
  502.         pnLoc:                    Point;
  503.         pnSize:                    Point;
  504.         pnMode:                    INTEGER;
  505.         pnPat:                    Pattern;
  506.         pnVis:                    INTEGER;
  507.         txFont:                    INTEGER;
  508.         txFace:                    StyleField;                                { StyleField occupies 16-bits, but only first 8-bits are used }
  509.         txMode:                    INTEGER;
  510.         txSize:                    INTEGER;
  511.         spExtra:                Fixed;
  512.         fgColor:                LONGINT;
  513.         bkColor:                LONGINT;
  514.         colrBit:                INTEGER;
  515.         patStretch:                INTEGER;
  516.         picSave:                Handle;
  517.         rgnSave:                Handle;
  518.         polySave:                Handle;
  519.         grafProcs:                QDProcsPtr;
  520.     END;
  521.  
  522.     GrafPtr                                = ^GrafPort;
  523.  
  524. {
  525.  *    This set of definitions "belongs" in Windows.
  526.  *    But, there is a circularity in the headers where Windows includes Controls and
  527.  *    Controls includes Windows. To break the circle, the information
  528.  *    needed by Controls is moved from Windows to Quickdraw.
  529.  }
  530.     WindowPtr                            = GrafPtr;
  531.     DialogPtr                            = WindowPtr;
  532.     WindowRef                            = WindowPtr;
  533. {  DragConstraint constants to pass to DragGray,DragTheRgn, or ConstrainedDragRgn }
  534.     DragConstraint                        = UInt16;
  535.  
  536. CONST
  537.     kNoConstraint                = 0;
  538.     kVerticalConstraint            = 1;
  539.     kHorizontalConstraint        = 2;
  540.  
  541.  
  542.  
  543. TYPE
  544.     DragGrayRgnProcPtr = ProcPtr;  { PROCEDURE DragGrayRgn; }
  545.  
  546. {
  547.  *    Here ends the list of things that "belong" in Windows.
  548.  }
  549.  
  550.  
  551.     RGBColorPtr = ^RGBColor;
  552.     RGBColor = RECORD
  553.         red:                    INTEGER;                                { magnitude of red component }
  554.         green:                    INTEGER;                                { magnitude of green component }
  555.         blue:                    INTEGER;                                { magnitude of blue component }
  556.     END;
  557.  
  558.     RGBColorHdl                            = ^RGBColorPtr;
  559.     ColorSearchProcPtr = ProcPtr;  { FUNCTION ColorSearch(VAR rgb: RGBColor; VAR position: LONGINT): BOOLEAN; }
  560.  
  561.     ColorComplementProcPtr = ProcPtr;  { FUNCTION ColorComplement(VAR rgb: RGBColor): BOOLEAN; }
  562.  
  563.     DragGrayRgnUPP = UniversalProcPtr;
  564.     ColorSearchUPP = UniversalProcPtr;
  565.     ColorComplementUPP = UniversalProcPtr;
  566.  
  567. CONST
  568.     uppDragGrayRgnProcInfo = $00000000;
  569.     uppColorSearchProcInfo = $000003D0;
  570.     uppColorComplementProcInfo = $000000D0;
  571.  
  572. FUNCTION NewDragGrayRgnProc(userRoutine: DragGrayRgnProcPtr): DragGrayRgnUPP;
  573.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  574.     INLINE $2E9F;
  575.     {$ENDC}
  576.  
  577. FUNCTION NewColorSearchProc(userRoutine: ColorSearchProcPtr): ColorSearchUPP;
  578.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  579.     INLINE $2E9F;
  580.     {$ENDC}
  581.  
  582. FUNCTION NewColorComplementProc(userRoutine: ColorComplementProcPtr): ColorComplementUPP;
  583.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  584.     INLINE $2E9F;
  585.     {$ENDC}
  586.  
  587. PROCEDURE CallDragGrayRgnProc(userRoutine: DragGrayRgnUPP);
  588.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  589.     INLINE $205F, $4E90;
  590.     {$ENDC}
  591.  
  592. FUNCTION CallColorSearchProc(VAR rgb: RGBColor; VAR position: LONGINT; userRoutine: ColorSearchUPP): BOOLEAN;
  593.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  594.     INLINE $205F, $4E90;
  595.     {$ENDC}
  596.  
  597. FUNCTION CallColorComplementProc(VAR rgb: RGBColor; userRoutine: ColorComplementUPP): BOOLEAN;
  598.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  599.     INLINE $205F, $4E90;
  600.     {$ENDC}
  601.  
  602. TYPE
  603.     ColorSpecPtr = ^ColorSpec;
  604.     ColorSpec = RECORD
  605.         value:                    INTEGER;                                { index or other value }
  606.         rgb:                    RGBColor;                                { true color }
  607.     END;
  608.  
  609.     CSpecArray                            = ARRAY [0..0] OF ColorSpec;
  610.     ColorTablePtr = ^ColorTable;
  611.     ColorTable = RECORD
  612.         ctSeed:                    LONGINT;                                { unique identifier for table }
  613.         ctFlags:                INTEGER;                                { high bit: 0 = PixMap; 1 = device }
  614.         ctSize:                    INTEGER;                                { number of entries in CTTable }
  615.         ctTable:                CSpecArray;                                { array [0..0] of ColorSpec }
  616.     END;
  617.  
  618.     CTabPtr                                = ^ColorTable;
  619.     CTabHandle                            = ^CTabPtr;
  620.     xColorSpecPtr = ^xColorSpec;
  621.     xColorSpec = RECORD
  622.         value:                    INTEGER;                                { index or other value }
  623.         rgb:                    RGBColor;                                { true color }
  624.         xalpha:                    INTEGER;
  625.     END;
  626.  
  627.     xCSpecArray                            = ARRAY [0..0] OF xColorSpec;
  628.     MatchRecPtr = ^MatchRec;
  629.     MatchRec = RECORD
  630.         red:                    INTEGER;
  631.         green:                    INTEGER;
  632.         blue:                    INTEGER;
  633.         matchData:                LONGINT;
  634.     END;
  635.  
  636.     PixMapPtr = ^PixMap;
  637.     PixMap = RECORD
  638.         baseAddr:                Ptr;                                    { pointer to pixels }
  639.         rowBytes:                INTEGER;                                { offset to next line }
  640.         bounds:                    Rect;                                    { encloses bitmap }
  641.         pmVersion:                INTEGER;                                { pixMap version number }
  642.         packType:                INTEGER;                                { defines packing format }
  643.         packSize:                LONGINT;                                { length of pixel data }
  644.         hRes:                    Fixed;                                    { horiz. resolution (ppi) }
  645.         vRes:                    Fixed;                                    { vert. resolution (ppi) }
  646.         pixelType:                INTEGER;                                { defines pixel type }
  647.         pixelSize:                INTEGER;                                { # bits in pixel }
  648.         cmpCount:                INTEGER;                                { # components in pixel }
  649.         cmpSize:                INTEGER;                                { # bits per component }
  650.         planeBytes:                LONGINT;                                { offset to next plane }
  651.         pmTable:                CTabHandle;                                { color map for this pixMap }
  652.         pmReserved:                LONGINT;                                { for future use. MUST BE 0 }
  653.     END;
  654.  
  655.     PixMapHandle                        = ^PixMapPtr;
  656.     PixPatPtr = ^PixPat;
  657.     PixPat = RECORD
  658.         patType:                INTEGER;                                { type of pattern }
  659.         patMap:                    PixMapHandle;                            { the pattern's pixMap }
  660.         patData:                Handle;                                    { pixmap's data }
  661.         patXData:                Handle;                                    { expanded Pattern data }
  662.         patXValid:                INTEGER;                                { flags whether expanded Pattern valid }
  663.         patXMap:                Handle;                                    { Handle to expanded Pattern data }
  664.         pat1Data:                Pattern;                                { old-Style pattern/RGB color }
  665.     END;
  666.  
  667.     PixPatHandle                        = ^PixPatPtr;
  668.     CCrsrPtr = ^CCrsr;
  669.     CCrsr = RECORD
  670.         crsrType:                INTEGER;                                { type of cursor }
  671.         crsrMap:                PixMapHandle;                            { the cursor's pixmap }
  672.         crsrData:                Handle;                                    { cursor's data }
  673.         crsrXData:                Handle;                                    { expanded cursor data }
  674.         crsrXValid:                INTEGER;                                { depth of expanded data (0 if none) }
  675.         crsrXHandle:            Handle;                                    { future use }
  676.         crsr1Data:                Bits16;                                    { one-bit cursor }
  677.         crsrMask:                Bits16;                                    { cursor's mask }
  678.         crsrHotSpot:            Point;                                    { cursor's hotspot }
  679.         crsrXTable:                LONGINT;                                { private }
  680.         crsrID:                    LONGINT;                                { private }
  681.     END;
  682.  
  683.     CCrsrHandle                            = ^CCrsrPtr;
  684. {$IFC OLDROUTINELOCATIONS }
  685.     CIconPtr = ^CIcon;
  686.     CIcon = RECORD
  687.         iconPMap:                PixMap;                                    { the icon's pixMap }
  688.         iconMask:                BitMap;                                    { the icon's mask }
  689.         iconBMap:                BitMap;                                    { the icon's bitMap }
  690.         iconData:                Handle;                                    { the icon's data }
  691.         iconMaskData:            ARRAY [0..0] OF INTEGER;                { icon's mask and BitMap data }
  692.     END;
  693.  
  694.     CIconHandle                            = ^CIconPtr;
  695. {$ENDC}  {OLDROUTINELOCATIONS}
  696.  
  697.     GammaTblPtr = ^GammaTbl;
  698.     GammaTbl = RECORD
  699.         gVersion:                INTEGER;                                { gamma version number }
  700.         gType:                    INTEGER;                                { gamma data type }
  701.         gFormulaSize:            INTEGER;                                { Formula data size }
  702.         gChanCnt:                INTEGER;                                { number of channels of data }
  703.         gDataCnt:                INTEGER;                                { number of values/channel }
  704.         gDataWidth:                INTEGER;                                { bits/corrected value (data packed to next larger byte size) }
  705.         gFormulaData:            ARRAY [0..0] OF INTEGER;                { data for formulas followed by gamma values }
  706.     END;
  707.  
  708.     GammaTblHandle                        = ^GammaTblPtr;
  709.     ITabPtr = ^ITab;
  710.     ITab = RECORD
  711.         iTabSeed:                LONGINT;                                { copy of CTSeed from source CTable }
  712.         iTabRes:                INTEGER;                                { bits/channel resolution of iTable }
  713.         iTTable:                SInt8;                                    { byte colortable index values }
  714.     END;
  715.  
  716.     ITabHandle                            = ^ITabPtr;
  717.     SProcRecPtr = ^SProcRec;
  718.     SProcRec = RECORD
  719.         nxtSrch:                Handle;                                    { SProcHndl Handle to next SProcRec }
  720.         srchProc:                ColorSearchUPP;                            { search procedure proc ptr }
  721.     END;
  722.  
  723.     SProcPtr                            = ^SProcRec;
  724.     SProcHndl                            = ^SProcPtr;
  725.     CProcRecPtr = ^CProcRec;
  726.     CProcRec = RECORD
  727.         nxtComp:                Handle;                                    { CProcHndl Handle to next CProcRec }
  728.         compProc:                ColorComplementUPP;                        { complement procedure proc ptr }
  729.     END;
  730.  
  731.     CProcPtr                            = ^CProcRec;
  732.     CProcHndl                            = ^CProcPtr;
  733.     GDevicePtr = ^GDevice;
  734.     GDevice = RECORD
  735.         gdRefNum:                INTEGER;                                { driver's unit number }
  736.         gdID:                    INTEGER;                                { client ID for search procs }
  737.         gdType:                    INTEGER;                                { fixed/CLUT/direct }
  738.         gdITable:                ITabHandle;                                { Handle to inverse lookup table }
  739.         gdResPref:                INTEGER;                                { preferred resolution of GDITable }
  740.         gdSearchProc:            SProcHndl;                                { search proc list head }
  741.         gdCompProc:                CProcHndl;                                { complement proc list }
  742.         gdFlags:                INTEGER;                                { grafDevice flags word }
  743.         gdPMap:                    PixMapHandle;                            { describing pixMap }
  744.         gdRefCon:                LONGINT;                                { reference value }
  745.         gdNextGD:                Handle;                                    { GDHandle Handle of next gDevice }
  746.         gdRect:                    Rect;                                    {  device's bounds in global coordinates }
  747.         gdMode:                    LONGINT;                                { device's current mode }
  748.         gdCCBytes:                INTEGER;                                { depth of expanded cursor data }
  749.         gdCCDepth:                INTEGER;                                { depth of expanded cursor data }
  750.         gdCCXData:                Handle;                                    { Handle to cursor's expanded data }
  751.         gdCCXMask:                Handle;                                    { Handle to cursor's expanded mask }
  752.         gdReserved:                LONGINT;                                { future use. MUST BE 0 }
  753.     END;
  754.  
  755.     GDPtr                                = ^GDevice;
  756.     GDHandle                            = ^GDPtr;
  757.     GrafVars = RECORD
  758.         rgbOpColor:                RGBColor;                                { color for addPin  subPin and average }
  759.         rgbHiliteColor:            RGBColor;                                { color for hiliting }
  760.         pmFgColor:                Handle;                                    { palette Handle for foreground color }
  761.         pmFgIndex:                INTEGER;                                { index value for foreground }
  762.         pmBkColor:                Handle;                                    { palette Handle for background color }
  763.         pmBkIndex:                INTEGER;                                { index value for background }
  764.         pmFlags:                INTEGER;                                { flags for Palette Manager }
  765.     END;
  766.     GVarPtr                                = ^GrafVars;
  767.     GVarHandle                            = ^GVarPtr;
  768.     CQDProcsPtr = ^CQDProcs;
  769.     CQDProcs = RECORD
  770.         textProc:                QDTextUPP;
  771.         lineProc:                QDLineUPP;
  772.         rectProc:                QDRectUPP;
  773.         rRectProc:                QDRRectUPP;
  774.         ovalProc:                QDOvalUPP;
  775.         arcProc:                QDArcUPP;
  776.         polyProc:                QDPolyUPP;
  777.         rgnProc:                QDRgnUPP;
  778.         bitsProc:                QDBitsUPP;
  779.         commentProc:            QDCommentUPP;
  780.         txMeasProc:                QDTxMeasUPP;
  781.         getPicProc:                QDGetPicUPP;
  782.         putPicProc:                QDPutPicUPP;
  783.         opcodeProc:                QDOpcodeUPP;                            { fields added to QDProcs }
  784.         newProc1:                UniversalProcPtr;
  785.         newProc2:                UniversalProcPtr;
  786.         newProc3:                UniversalProcPtr;
  787.         newProc4:                UniversalProcPtr;
  788.         newProc5:                UniversalProcPtr;
  789.         newProc6:                UniversalProcPtr;
  790.     END;
  791.  
  792.     CGrafPortPtr = ^CGrafPort;
  793.     CGrafPort = RECORD
  794.         device:                    INTEGER;
  795.         portPixMap:                PixMapHandle;                            { port's pixel map }
  796.         portVersion:            INTEGER;                                { high 2 bits always set }
  797.         grafVars:                Handle;                                    { Handle to more fields }
  798.         chExtra:                INTEGER;                                { character extra }
  799.         pnLocHFrac:                INTEGER;                                { pen fraction }
  800.         portRect:                Rect;
  801.         visRgn:                    RgnHandle;
  802.         clipRgn:                RgnHandle;
  803.         bkPixPat:                PixPatHandle;                            { background pattern }
  804.         rgbFgColor:                RGBColor;                                { RGB components of fg }
  805.         rgbBkColor:                RGBColor;                                { RGB components of bk }
  806.         pnLoc:                    Point;
  807.         pnSize:                    Point;
  808.         pnMode:                    INTEGER;
  809.         pnPixPat:                PixPatHandle;                            { pen's pattern }
  810.         fillPixPat:                PixPatHandle;                            { fill pattern }
  811.         pnVis:                    INTEGER;
  812.         txFont:                    INTEGER;
  813.         txFace:                    StyleField;                                { StyleField occupies 16-bits, but only first 8-bits are used }
  814.         txMode:                    INTEGER;
  815.         txSize:                    INTEGER;
  816.         spExtra:                Fixed;
  817.         fgColor:                LONGINT;
  818.         bkColor:                LONGINT;
  819.         colrBit:                INTEGER;
  820.         patStretch:                INTEGER;
  821.         picSave:                Handle;
  822.         rgnSave:                Handle;
  823.         polySave:                Handle;
  824.         grafProcs:                CQDProcsPtr;
  825.     END;
  826.  
  827.     CGrafPtr                            = ^CGrafPort;
  828.     CWindowPtr                            = CGrafPtr;
  829.     ReqListRecPtr = ^ReqListRec;
  830.     ReqListRec = RECORD
  831.         reqLSize:                INTEGER;                                { request list size }
  832.         reqLData:                ARRAY [0..0] OF INTEGER;                { request list data }
  833.     END;
  834.  
  835.     OpenCPicParamsPtr = ^OpenCPicParams;
  836.     OpenCPicParams = RECORD
  837.         srcRect:                Rect;
  838.         hRes:                    Fixed;
  839.         vRes:                    Fixed;
  840.         version:                INTEGER;
  841.         reserved1:                INTEGER;
  842.         reserved2:                LONGINT;
  843.     END;
  844.  
  845.  
  846. CONST
  847.     kCursorImageMajorVersion    = $0001;
  848.     kCursorImageMinorVersion    = $0000;
  849.  
  850.  
  851. TYPE
  852.     CursorImageRecPtr = ^CursorImageRec;
  853.     CursorImageRec = RECORD
  854.         majorVersion:            UInt16;
  855.         minorVersion:            UInt16;
  856.         cursorPixMap:            PixMapHandle;
  857.         cursorBitMask:            BitMapHandle;
  858.     END;
  859.  
  860.     CursorImagePtr                        = ^CursorImageRec;
  861.     DeviceLoopDrawingProcPtr = ProcPtr;  { PROCEDURE DeviceLoopDrawing(depth: INTEGER; deviceFlags: INTEGER; targetDevice: GDHandle; userData: LONGINT); }
  862.  
  863.     DeviceLoopDrawingUPP = UniversalProcPtr;
  864.  
  865. CONST
  866.     uppDeviceLoopDrawingProcInfo = $00003E80;
  867.  
  868. FUNCTION NewDeviceLoopDrawingProc(userRoutine: DeviceLoopDrawingProcPtr): DeviceLoopDrawingUPP;
  869.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  870.     INLINE $2E9F;
  871.     {$ENDC}
  872.  
  873. PROCEDURE CallDeviceLoopDrawingProc(depth: INTEGER; deviceFlags: INTEGER; targetDevice: GDHandle; userData: LONGINT; userRoutine: DeviceLoopDrawingUPP);
  874.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  875.     INLINE $205F, $4E90;
  876.     {$ENDC}
  877.  
  878. TYPE
  879.     QDGlobalsPtr = ^QDGlobals;
  880.     QDGlobals = RECORD
  881.         privates:                PACKED ARRAY [0..75] OF CHAR;
  882.         randSeed:                LONGINT;
  883.         screenBits:                BitMap;
  884.         arrow:                    Cursor;
  885.         dkGray:                    Pattern;
  886.         ltGray:                    Pattern;
  887.         gray:                    Pattern;
  888.         black:                    Pattern;
  889.         white:                    Pattern;
  890.         thePort:                GrafPtr;
  891.     END;
  892.  
  893.     QDGlobalsHdl                        = ^QDGlobalsPtr;
  894.  
  895. { To be in sync with the C interface to QuickDraw globals, pascal code must now }
  896. { qualify the QuickDraw globals with “qd.” (e.g. InitGraf(@qd.thePort);  )       }
  897. VAR
  898.     {$PUSH}
  899.     {$J+}
  900.     qd: QDGlobals;
  901.     {$POP}
  902.  
  903.  
  904. PROCEDURE InitGraf(globalPtr: UNIV Ptr);
  905.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  906.     INLINE $A86E;
  907.     {$ENDC}
  908. PROCEDURE OpenPort(port: GrafPtr);
  909.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  910.     INLINE $A86F;
  911.     {$ENDC}
  912. PROCEDURE InitPort(port: GrafPtr);
  913.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  914.     INLINE $A86D;
  915.     {$ENDC}
  916. PROCEDURE ClosePort(port: GrafPtr);
  917.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  918.     INLINE $A87D;
  919.     {$ENDC}
  920. PROCEDURE SetPort(port: GrafPtr);
  921.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  922.     INLINE $A873;
  923.     {$ENDC}
  924. PROCEDURE GetPort(VAR port: GrafPtr);
  925.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  926.     INLINE $A874;
  927.     {$ENDC}
  928. PROCEDURE GrafDevice(device: INTEGER);
  929.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  930.     INLINE $A872;
  931.     {$ENDC}
  932. PROCEDURE SetPortBits({CONST}VAR bm: BitMap);
  933.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  934.     INLINE $A875;
  935.     {$ENDC}
  936. PROCEDURE PortSize(width: INTEGER; height: INTEGER);
  937.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  938.     INLINE $A876;
  939.     {$ENDC}
  940. PROCEDURE MovePortTo(leftGlobal: INTEGER; topGlobal: INTEGER);
  941.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  942.     INLINE $A877;
  943.     {$ENDC}
  944. PROCEDURE SetOrigin(h: INTEGER; v: INTEGER);
  945.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  946.     INLINE $A878;
  947.     {$ENDC}
  948. PROCEDURE SetClip(rgn: RgnHandle);
  949.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  950.     INLINE $A879;
  951.     {$ENDC}
  952. PROCEDURE GetClip(rgn: RgnHandle);
  953.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  954.     INLINE $A87A;
  955.     {$ENDC}
  956. PROCEDURE ClipRect({CONST}VAR r: Rect);
  957.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  958.     INLINE $A87B;
  959.     {$ENDC}
  960. PROCEDURE BackPat({CONST}VAR pat: Pattern);
  961.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  962.     INLINE $A87C;
  963.     {$ENDC}
  964. PROCEDURE InitCursor;
  965.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  966.     INLINE $A850;
  967.     {$ENDC}
  968. PROCEDURE SetCursor({CONST}VAR crsr: Cursor);
  969.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  970.     INLINE $A851;
  971.     {$ENDC}
  972. PROCEDURE HideCursor;
  973.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  974.     INLINE $A852;
  975.     {$ENDC}
  976. PROCEDURE ShowCursor;
  977.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  978.     INLINE $A853;
  979.     {$ENDC}
  980. PROCEDURE ObscureCursor;
  981.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  982.     INLINE $A856;
  983.     {$ENDC}
  984. PROCEDURE HidePen;
  985.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  986.     INLINE $A896;
  987.     {$ENDC}
  988. PROCEDURE ShowPen;
  989.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  990.     INLINE $A897;
  991.     {$ENDC}
  992. PROCEDURE GetPen(VAR pt: Point);
  993.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  994.     INLINE $A89A;
  995.     {$ENDC}
  996. PROCEDURE GetPenState(VAR pnState: PenState);
  997.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  998.     INLINE $A898;
  999.     {$ENDC}
  1000. PROCEDURE SetPenState({CONST}VAR pnState: PenState);
  1001.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1002.     INLINE $A899;
  1003.     {$ENDC}
  1004. PROCEDURE PenSize(width: INTEGER; height: INTEGER);
  1005.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1006.     INLINE $A89B;
  1007.     {$ENDC}
  1008. PROCEDURE PenMode(mode: INTEGER);
  1009.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1010.     INLINE $A89C;
  1011.     {$ENDC}
  1012. PROCEDURE PenPat({CONST}VAR pat: Pattern);
  1013.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1014.     INLINE $A89D;
  1015.     {$ENDC}
  1016. PROCEDURE PenNormal;
  1017.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1018.     INLINE $A89E;
  1019.     {$ENDC}
  1020. PROCEDURE MoveTo(h: INTEGER; v: INTEGER);
  1021.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1022.     INLINE $A893;
  1023.     {$ENDC}
  1024. PROCEDURE Move(dh: INTEGER; dv: INTEGER);
  1025.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1026.     INLINE $A894;
  1027.     {$ENDC}
  1028. PROCEDURE LineTo(h: INTEGER; v: INTEGER);
  1029.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1030.     INLINE $A891;
  1031.     {$ENDC}
  1032. PROCEDURE Line(dh: INTEGER; dv: INTEGER);
  1033.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1034.     INLINE $A892;
  1035.     {$ENDC}
  1036. PROCEDURE ForeColor(color: LONGINT);
  1037.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1038.     INLINE $A862;
  1039.     {$ENDC}
  1040. PROCEDURE BackColor(color: LONGINT);
  1041.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1042.     INLINE $A863;
  1043.     {$ENDC}
  1044. PROCEDURE ColorBit(whichBit: INTEGER);
  1045.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1046.     INLINE $A864;
  1047.     {$ENDC}
  1048. PROCEDURE SetRect(VAR r: Rect; left: INTEGER; top: INTEGER; right: INTEGER; bottom: INTEGER);
  1049.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1050.     INLINE $A8A7;
  1051.     {$ENDC}
  1052. PROCEDURE OffsetRect(VAR r: Rect; dh: INTEGER; dv: INTEGER);
  1053.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1054.     INLINE $A8A8;
  1055.     {$ENDC}
  1056. PROCEDURE InsetRect(VAR r: Rect; dh: INTEGER; dv: INTEGER);
  1057.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1058.     INLINE $A8A9;
  1059.     {$ENDC}
  1060. FUNCTION SectRect({CONST}VAR src1: Rect; {CONST}VAR src2: Rect; VAR dstRect: Rect): BOOLEAN;
  1061.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1062.     INLINE $A8AA;
  1063.     {$ENDC}
  1064. PROCEDURE UnionRect({CONST}VAR src1: Rect; {CONST}VAR src2: Rect; VAR dstRect: Rect);
  1065.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1066.     INLINE $A8AB;
  1067.     {$ENDC}
  1068. FUNCTION EqualRect({CONST}VAR rect1: Rect; {CONST}VAR rect2: Rect): BOOLEAN;
  1069.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1070.     INLINE $A8A6;
  1071.     {$ENDC}
  1072. FUNCTION EmptyRect({CONST}VAR r: Rect): BOOLEAN;
  1073.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1074.     INLINE $A8AE;
  1075.     {$ENDC}
  1076. PROCEDURE FrameRect({CONST}VAR r: Rect);
  1077.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1078.     INLINE $A8A1;
  1079.     {$ENDC}
  1080. PROCEDURE PaintRect({CONST}VAR r: Rect);
  1081.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1082.     INLINE $A8A2;
  1083.     {$ENDC}
  1084. PROCEDURE EraseRect({CONST}VAR r: Rect);
  1085.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1086.     INLINE $A8A3;
  1087.     {$ENDC}
  1088. PROCEDURE InvertRect({CONST}VAR r: Rect);
  1089.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1090.     INLINE $A8A4;
  1091.     {$ENDC}
  1092. PROCEDURE FillRect({CONST}VAR r: Rect; {CONST}VAR pat: Pattern);
  1093.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1094.     INLINE $A8A5;
  1095.     {$ENDC}
  1096. PROCEDURE FrameOval({CONST}VAR r: Rect);
  1097.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1098.     INLINE $A8B7;
  1099.     {$ENDC}
  1100. PROCEDURE PaintOval({CONST}VAR r: Rect);
  1101.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1102.     INLINE $A8B8;
  1103.     {$ENDC}
  1104. PROCEDURE EraseOval({CONST}VAR r: Rect);
  1105.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1106.     INLINE $A8B9;
  1107.     {$ENDC}
  1108. PROCEDURE InvertOval({CONST}VAR r: Rect);
  1109.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1110.     INLINE $A8BA;
  1111.     {$ENDC}
  1112. PROCEDURE FillOval({CONST}VAR r: Rect; {CONST}VAR pat: Pattern);
  1113.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1114.     INLINE $A8BB;
  1115.     {$ENDC}
  1116. PROCEDURE FrameRoundRect({CONST}VAR r: Rect; ovalWidth: INTEGER; ovalHeight: INTEGER);
  1117.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1118.     INLINE $A8B0;
  1119.     {$ENDC}
  1120. PROCEDURE PaintRoundRect({CONST}VAR r: Rect; ovalWidth: INTEGER; ovalHeight: INTEGER);
  1121.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1122.     INLINE $A8B1;
  1123.     {$ENDC}
  1124. PROCEDURE EraseRoundRect({CONST}VAR r: Rect; ovalWidth: INTEGER; ovalHeight: INTEGER);
  1125.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1126.     INLINE $A8B2;
  1127.     {$ENDC}
  1128. PROCEDURE InvertRoundRect({CONST}VAR r: Rect; ovalWidth: INTEGER; ovalHeight: INTEGER);
  1129.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1130.     INLINE $A8B3;
  1131.     {$ENDC}
  1132. PROCEDURE FillRoundRect({CONST}VAR r: Rect; ovalWidth: INTEGER; ovalHeight: INTEGER; {CONST}VAR pat: Pattern);
  1133.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1134.     INLINE $A8B4;
  1135.     {$ENDC}
  1136. PROCEDURE FrameArc({CONST}VAR r: Rect; startAngle: INTEGER; arcAngle: INTEGER);
  1137.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1138.     INLINE $A8BE;
  1139.     {$ENDC}
  1140. PROCEDURE PaintArc({CONST}VAR r: Rect; startAngle: INTEGER; arcAngle: INTEGER);
  1141.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1142.     INLINE $A8BF;
  1143.     {$ENDC}
  1144. PROCEDURE EraseArc({CONST}VAR r: Rect; startAngle: INTEGER; arcAngle: INTEGER);
  1145.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1146.     INLINE $A8C0;
  1147.     {$ENDC}
  1148. PROCEDURE InvertArc({CONST}VAR r: Rect; startAngle: INTEGER; arcAngle: INTEGER);
  1149.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1150.     INLINE $A8C1;
  1151.     {$ENDC}
  1152. PROCEDURE FillArc({CONST}VAR r: Rect; startAngle: INTEGER; arcAngle: INTEGER; {CONST}VAR pat: Pattern);
  1153.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1154.     INLINE $A8C2;
  1155.     {$ENDC}
  1156. FUNCTION NewRgn: RgnHandle;
  1157.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1158.     INLINE $A8D8;
  1159.     {$ENDC}
  1160. PROCEDURE OpenRgn;
  1161.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1162.     INLINE $A8DA;
  1163.     {$ENDC}
  1164. PROCEDURE CloseRgn(dstRgn: RgnHandle);
  1165.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1166.     INLINE $A8DB;
  1167.     {$ENDC}
  1168. FUNCTION BitMapToRegion(region: RgnHandle; {CONST}VAR bMap: BitMap): OSErr;
  1169.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1170.     INLINE $A8D7;
  1171.     {$ENDC}
  1172. PROCEDURE DisposeRgn(rgn: RgnHandle);
  1173.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1174.     INLINE $A8D9;
  1175.     {$ENDC}
  1176. PROCEDURE CopyRgn(srcRgn: RgnHandle; dstRgn: RgnHandle);
  1177.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1178.     INLINE $A8DC;
  1179.     {$ENDC}
  1180. PROCEDURE SetEmptyRgn(rgn: RgnHandle);
  1181.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1182.     INLINE $A8DD;
  1183.     {$ENDC}
  1184. PROCEDURE SetRectRgn(rgn: RgnHandle; left: INTEGER; top: INTEGER; right: INTEGER; bottom: INTEGER);
  1185.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1186.     INLINE $A8DE;
  1187.     {$ENDC}
  1188. PROCEDURE RectRgn(rgn: RgnHandle; {CONST}VAR r: Rect);
  1189.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1190.     INLINE $A8DF;
  1191.     {$ENDC}
  1192. PROCEDURE OffsetRgn(rgn: RgnHandle; dh: INTEGER; dv: INTEGER);
  1193.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1194.     INLINE $A8E0;
  1195.     {$ENDC}
  1196. PROCEDURE InsetRgn(rgn: RgnHandle; dh: INTEGER; dv: INTEGER);
  1197.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1198.     INLINE $A8E1;
  1199.     {$ENDC}
  1200. PROCEDURE SectRgn(srcRgnA: RgnHandle; srcRgnB: RgnHandle; dstRgn: RgnHandle);
  1201.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1202.     INLINE $A8E4;
  1203.     {$ENDC}
  1204. PROCEDURE UnionRgn(srcRgnA: RgnHandle; srcRgnB: RgnHandle; dstRgn: RgnHandle);
  1205.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1206.     INLINE $A8E5;
  1207.     {$ENDC}
  1208. PROCEDURE DiffRgn(srcRgnA: RgnHandle; srcRgnB: RgnHandle; dstRgn: RgnHandle);
  1209.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1210.     INLINE $A8E6;
  1211.     {$ENDC}
  1212. PROCEDURE XorRgn(srcRgnA: RgnHandle; srcRgnB: RgnHandle; dstRgn: RgnHandle);
  1213.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1214.     INLINE $A8E7;
  1215.     {$ENDC}
  1216. FUNCTION RectInRgn({CONST}VAR r: Rect; rgn: RgnHandle): BOOLEAN;
  1217.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1218.     INLINE $A8E9;
  1219.     {$ENDC}
  1220. FUNCTION EqualRgn(rgnA: RgnHandle; rgnB: RgnHandle): BOOLEAN;
  1221.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1222.     INLINE $A8E3;
  1223.     {$ENDC}
  1224. FUNCTION EmptyRgn(rgn: RgnHandle): BOOLEAN;
  1225.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1226.     INLINE $A8E2;
  1227.     {$ENDC}
  1228. PROCEDURE FrameRgn(rgn: RgnHandle);
  1229.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1230.     INLINE $A8D2;
  1231.     {$ENDC}
  1232. PROCEDURE PaintRgn(rgn: RgnHandle);
  1233.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1234.     INLINE $A8D3;
  1235.     {$ENDC}
  1236. PROCEDURE EraseRgn(rgn: RgnHandle);
  1237.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1238.     INLINE $A8D4;
  1239.     {$ENDC}
  1240. PROCEDURE InvertRgn(rgn: RgnHandle);
  1241.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1242.     INLINE $A8D5;
  1243.     {$ENDC}
  1244. PROCEDURE FillRgn(rgn: RgnHandle; {CONST}VAR pat: Pattern);
  1245.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1246.     INLINE $A8D6;
  1247.     {$ENDC}
  1248. PROCEDURE ScrollRect({CONST}VAR r: Rect; dh: INTEGER; dv: INTEGER; updateRgn: RgnHandle);
  1249.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1250.     INLINE $A8EF;
  1251.     {$ENDC}
  1252. PROCEDURE CopyBits({CONST}VAR srcBits: BitMap; {CONST}VAR dstBits: BitMap; {CONST}VAR srcRect: Rect; {CONST}VAR dstRect: Rect; mode: INTEGER; maskRgn: RgnHandle);
  1253.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1254.     INLINE $A8EC;
  1255.     {$ENDC}
  1256. PROCEDURE SeedFill(srcPtr: UNIV Ptr; dstPtr: UNIV Ptr; srcRow: INTEGER; dstRow: INTEGER; height: INTEGER; words: INTEGER; seedH: INTEGER; seedV: INTEGER);
  1257.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1258.     INLINE $A839;
  1259.     {$ENDC}
  1260. PROCEDURE CalcMask(srcPtr: UNIV Ptr; dstPtr: UNIV Ptr; srcRow: INTEGER; dstRow: INTEGER; height: INTEGER; words: INTEGER);
  1261.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1262.     INLINE $A838;
  1263.     {$ENDC}
  1264. PROCEDURE CopyMask({CONST}VAR srcBits: BitMap; {CONST}VAR maskBits: BitMap; {CONST}VAR dstBits: BitMap; {CONST}VAR srcRect: Rect; {CONST}VAR maskRect: Rect; {CONST}VAR dstRect: Rect);
  1265.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1266.     INLINE $A817;
  1267.     {$ENDC}
  1268. FUNCTION OpenPicture({CONST}VAR picFrame: Rect): PicHandle;
  1269.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1270.     INLINE $A8F3;
  1271.     {$ENDC}
  1272. PROCEDURE PicComment(kind: INTEGER; dataSize: INTEGER; dataHandle: Handle);
  1273.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1274.     INLINE $A8F2;
  1275.     {$ENDC}
  1276. PROCEDURE ClosePicture;
  1277.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1278.     INLINE $A8F4;
  1279.     {$ENDC}
  1280. PROCEDURE DrawPicture(myPicture: PicHandle; {CONST}VAR dstRect: Rect);
  1281.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1282.     INLINE $A8F6;
  1283.     {$ENDC}
  1284. PROCEDURE KillPicture(myPicture: PicHandle);
  1285.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1286.     INLINE $A8F5;
  1287.     {$ENDC}
  1288. FUNCTION OpenPoly: PolyHandle;
  1289.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1290.     INLINE $A8CB;
  1291.     {$ENDC}
  1292. PROCEDURE ClosePoly;
  1293.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1294.     INLINE $A8CC;
  1295.     {$ENDC}
  1296. PROCEDURE KillPoly(poly: PolyHandle);
  1297.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1298.     INLINE $A8CD;
  1299.     {$ENDC}
  1300. PROCEDURE OffsetPoly(poly: PolyHandle; dh: INTEGER; dv: INTEGER);
  1301.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1302.     INLINE $A8CE;
  1303.     {$ENDC}
  1304. PROCEDURE FramePoly(poly: PolyHandle);
  1305.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1306.     INLINE $A8C6;
  1307.     {$ENDC}
  1308. PROCEDURE PaintPoly(poly: PolyHandle);
  1309.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1310.     INLINE $A8C7;
  1311.     {$ENDC}
  1312. PROCEDURE ErasePoly(poly: PolyHandle);
  1313.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1314.     INLINE $A8C8;
  1315.     {$ENDC}
  1316. PROCEDURE InvertPoly(poly: PolyHandle);
  1317.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1318.     INLINE $A8C9;
  1319.     {$ENDC}
  1320. PROCEDURE FillPoly(poly: PolyHandle; {CONST}VAR pat: Pattern);
  1321.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1322.     INLINE $A8CA;
  1323.     {$ENDC}
  1324. PROCEDURE SetPt(VAR pt: Point; h: INTEGER; v: INTEGER);
  1325.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1326.     INLINE $A880;
  1327.     {$ENDC}
  1328. PROCEDURE LocalToGlobal(VAR pt: Point);
  1329.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1330.     INLINE $A870;
  1331.     {$ENDC}
  1332. PROCEDURE GlobalToLocal(VAR pt: Point);
  1333.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1334.     INLINE $A871;
  1335.     {$ENDC}
  1336. FUNCTION Random: INTEGER;
  1337.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1338.     INLINE $A861;
  1339.     {$ENDC}
  1340. PROCEDURE StuffHex(thingPtr: UNIV Ptr; s: ConstStr255Param);
  1341.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1342.     INLINE $A866;
  1343.     {$ENDC}
  1344. FUNCTION GetPixel(h: INTEGER; v: INTEGER): BOOLEAN;
  1345.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1346.     INLINE $A865;
  1347.     {$ENDC}
  1348. PROCEDURE ScalePt(VAR pt: Point; {CONST}VAR srcRect: Rect; {CONST}VAR dstRect: Rect);
  1349.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1350.     INLINE $A8F8;
  1351.     {$ENDC}
  1352. PROCEDURE MapPt(VAR pt: Point; {CONST}VAR srcRect: Rect; {CONST}VAR dstRect: Rect);
  1353.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1354.     INLINE $A8F9;
  1355.     {$ENDC}
  1356. PROCEDURE MapRect(VAR r: Rect; {CONST}VAR srcRect: Rect; {CONST}VAR dstRect: Rect);
  1357.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1358.     INLINE $A8FA;
  1359.     {$ENDC}
  1360. PROCEDURE MapRgn(rgn: RgnHandle; {CONST}VAR srcRect: Rect; {CONST}VAR dstRect: Rect);
  1361.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1362.     INLINE $A8FB;
  1363.     {$ENDC}
  1364. PROCEDURE MapPoly(poly: PolyHandle; {CONST}VAR srcRect: Rect; {CONST}VAR dstRect: Rect);
  1365.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1366.     INLINE $A8FC;
  1367.     {$ENDC}
  1368. PROCEDURE SetStdProcs(VAR procs: QDProcs);
  1369.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1370.     INLINE $A8EA;
  1371.     {$ENDC}
  1372. PROCEDURE StdRect(verb: GrafVerb; {CONST}VAR r: Rect);
  1373.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1374.     INLINE $A8A0;
  1375.     {$ENDC}
  1376. PROCEDURE StdRRect(verb: GrafVerb; {CONST}VAR r: Rect; ovalWidth: INTEGER; ovalHeight: INTEGER);
  1377.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1378.     INLINE $A8AF;
  1379.     {$ENDC}
  1380. PROCEDURE StdOval(verb: GrafVerb; {CONST}VAR r: Rect);
  1381.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1382.     INLINE $A8B6;
  1383.     {$ENDC}
  1384. PROCEDURE StdArc(verb: GrafVerb; {CONST}VAR r: Rect; startAngle: INTEGER; arcAngle: INTEGER);
  1385.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1386.     INLINE $A8BD;
  1387.     {$ENDC}
  1388. PROCEDURE StdPoly(verb: GrafVerb; poly: PolyHandle);
  1389.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1390.     INLINE $A8C5;
  1391.     {$ENDC}
  1392. PROCEDURE StdRgn(verb: GrafVerb; rgn: RgnHandle);
  1393.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1394.     INLINE $A8D1;
  1395.     {$ENDC}
  1396. PROCEDURE StdBits({CONST}VAR srcBits: BitMap; {CONST}VAR srcRect: Rect; {CONST}VAR dstRect: Rect; mode: INTEGER; maskRgn: RgnHandle);
  1397.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1398.     INLINE $A8EB;
  1399.     {$ENDC}
  1400. PROCEDURE StdComment(kind: INTEGER; dataSize: INTEGER; dataHandle: Handle);
  1401.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1402.     INLINE $A8F1;
  1403.     {$ENDC}
  1404. PROCEDURE StdGetPic(dataPtr: UNIV Ptr; byteCount: INTEGER);
  1405.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1406.     INLINE $A8EE;
  1407.     {$ENDC}
  1408. PROCEDURE StdPutPic(dataPtr: UNIV Ptr; byteCount: INTEGER);
  1409.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1410.     INLINE $A8F0;
  1411.     {$ENDC}
  1412. PROCEDURE StdOpcode({CONST}VAR fromRect: Rect; {CONST}VAR toRect: Rect; opcode: UInt16; version: SInt16);
  1413.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1414.     INLINE $ABF8;
  1415.     {$ENDC}
  1416. PROCEDURE AddPt(src: Point; VAR dst: Point);
  1417.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1418.     INLINE $A87E;
  1419.     {$ENDC}
  1420. FUNCTION EqualPt(pt1: Point; pt2: Point): BOOLEAN;
  1421.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1422.     INLINE $A881;
  1423.     {$ENDC}
  1424. FUNCTION PtInRect(pt: Point; {CONST}VAR r: Rect): BOOLEAN;
  1425.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1426.     INLINE $A8AD;
  1427.     {$ENDC}
  1428. PROCEDURE Pt2Rect(pt1: Point; pt2: Point; VAR dstRect: Rect);
  1429.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1430.     INLINE $A8AC;
  1431.     {$ENDC}
  1432. PROCEDURE PtToAngle({CONST}VAR r: Rect; pt: Point; VAR angle: INTEGER);
  1433.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1434.     INLINE $A8C3;
  1435.     {$ENDC}
  1436. PROCEDURE SubPt(src: Point; VAR dst: Point);
  1437.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1438.     INLINE $A87F;
  1439.     {$ENDC}
  1440. FUNCTION PtInRgn(pt: Point; rgn: RgnHandle): BOOLEAN;
  1441.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1442.     INLINE $A8E8;
  1443.     {$ENDC}
  1444. PROCEDURE StdLine(newPt: Point);
  1445.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1446.     INLINE $A890;
  1447.     {$ENDC}
  1448. PROCEDURE OpenCPort(port: CGrafPtr);
  1449.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1450.     INLINE $AA00;
  1451.     {$ENDC}
  1452. PROCEDURE InitCPort(port: CGrafPtr);
  1453.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1454.     INLINE $AA01;
  1455.     {$ENDC}
  1456. PROCEDURE CloseCPort(port: CGrafPtr);
  1457.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1458.     INLINE $AA02;
  1459.     {$ENDC}
  1460. FUNCTION NewPixMap: PixMapHandle;
  1461.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1462.     INLINE $AA03;
  1463.     {$ENDC}
  1464. PROCEDURE DisposePixMap(pm: PixMapHandle);
  1465.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1466.     INLINE $AA04;
  1467.     {$ENDC}
  1468. PROCEDURE CopyPixMap(srcPM: PixMapHandle; dstPM: PixMapHandle);
  1469.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1470.     INLINE $AA05;
  1471.     {$ENDC}
  1472. FUNCTION NewPixPat: PixPatHandle;
  1473.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1474.     INLINE $AA07;
  1475.     {$ENDC}
  1476. PROCEDURE DisposePixPat(pp: PixPatHandle);
  1477.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1478.     INLINE $AA08;
  1479.     {$ENDC}
  1480. PROCEDURE CopyPixPat(srcPP: PixPatHandle; dstPP: PixPatHandle);
  1481.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1482.     INLINE $AA09;
  1483.     {$ENDC}
  1484. PROCEDURE PenPixPat(pp: PixPatHandle);
  1485.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1486.     INLINE $AA0A;
  1487.     {$ENDC}
  1488. PROCEDURE BackPixPat(pp: PixPatHandle);
  1489.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1490.     INLINE $AA0B;
  1491.     {$ENDC}
  1492. FUNCTION GetPixPat(patID: INTEGER): PixPatHandle;
  1493.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1494.     INLINE $AA0C;
  1495.     {$ENDC}
  1496. PROCEDURE MakeRGBPat(pp: PixPatHandle; {CONST}VAR myColor: RGBColor);
  1497.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1498.     INLINE $AA0D;
  1499.     {$ENDC}
  1500. PROCEDURE FillCRect({CONST}VAR r: Rect; pp: PixPatHandle);
  1501.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1502.     INLINE $AA0E;
  1503.     {$ENDC}
  1504. PROCEDURE FillCOval({CONST}VAR r: Rect; pp: PixPatHandle);
  1505.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1506.     INLINE $AA0F;
  1507.     {$ENDC}
  1508. PROCEDURE FillCRoundRect({CONST}VAR r: Rect; ovalWidth: INTEGER; ovalHeight: INTEGER; pp: PixPatHandle);
  1509.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1510.     INLINE $AA10;
  1511.     {$ENDC}
  1512. PROCEDURE FillCArc({CONST}VAR r: Rect; startAngle: INTEGER; arcAngle: INTEGER; pp: PixPatHandle);
  1513.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1514.     INLINE $AA11;
  1515.     {$ENDC}
  1516. PROCEDURE FillCRgn(rgn: RgnHandle; pp: PixPatHandle);
  1517.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1518.     INLINE $AA12;
  1519.     {$ENDC}
  1520. PROCEDURE FillCPoly(poly: PolyHandle; pp: PixPatHandle);
  1521.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1522.     INLINE $AA13;
  1523.     {$ENDC}
  1524. PROCEDURE RGBForeColor({CONST}VAR color: RGBColor);
  1525.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1526.     INLINE $AA14;
  1527.     {$ENDC}
  1528. PROCEDURE RGBBackColor({CONST}VAR color: RGBColor);
  1529.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1530.     INLINE $AA15;
  1531.     {$ENDC}
  1532. PROCEDURE SetCPixel(h: INTEGER; v: INTEGER; {CONST}VAR cPix: RGBColor);
  1533.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1534.     INLINE $AA16;
  1535.     {$ENDC}
  1536. PROCEDURE SetPortPix(pm: PixMapHandle);
  1537.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1538.     INLINE $AA06;
  1539.     {$ENDC}
  1540. PROCEDURE GetCPixel(h: INTEGER; v: INTEGER; VAR cPix: RGBColor);
  1541.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1542.     INLINE $AA17;
  1543.     {$ENDC}
  1544. PROCEDURE GetForeColor(VAR color: RGBColor);
  1545.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1546.     INLINE $AA19;
  1547.     {$ENDC}
  1548. PROCEDURE GetBackColor(VAR color: RGBColor);
  1549.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1550.     INLINE $AA1A;
  1551.     {$ENDC}
  1552. PROCEDURE SeedCFill({CONST}VAR srcBits: BitMap; {CONST}VAR dstBits: BitMap; {CONST}VAR srcRect: Rect; {CONST}VAR dstRect: Rect; seedH: INTEGER; seedV: INTEGER; matchProc: ColorSearchUPP; matchData: LONGINT);
  1553.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1554.     INLINE $AA50;
  1555.     {$ENDC}
  1556. PROCEDURE CalcCMask({CONST}VAR srcBits: BitMap; {CONST}VAR dstBits: BitMap; {CONST}VAR srcRect: Rect; {CONST}VAR dstRect: Rect; {CONST}VAR seedRGB: RGBColor; matchProc: ColorSearchUPP; matchData: LONGINT);
  1557.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1558.     INLINE $AA4F;
  1559.     {$ENDC}
  1560. FUNCTION OpenCPicture({CONST}VAR newHeader: OpenCPicParams): PicHandle;
  1561.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1562.     INLINE $AA20;
  1563.     {$ENDC}
  1564. PROCEDURE OpColor({CONST}VAR color: RGBColor);
  1565.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1566.     INLINE $AA21;
  1567.     {$ENDC}
  1568. PROCEDURE HiliteColor({CONST}VAR color: RGBColor);
  1569.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1570.     INLINE $AA22;
  1571.     {$ENDC}
  1572. PROCEDURE DisposeCTable(cTable: CTabHandle);
  1573.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1574.     INLINE $AA24;
  1575.     {$ENDC}
  1576. FUNCTION GetCTable(ctID: INTEGER): CTabHandle;
  1577.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1578.     INLINE $AA18;
  1579.     {$ENDC}
  1580. FUNCTION GetCCursor(crsrID: INTEGER): CCrsrHandle;
  1581.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1582.     INLINE $AA1B;
  1583.     {$ENDC}
  1584. PROCEDURE SetCCursor(cCrsr: CCrsrHandle);
  1585.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1586.     INLINE $AA1C;
  1587.     {$ENDC}
  1588. PROCEDURE AllocCursor;
  1589.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1590.     INLINE $AA1D;
  1591.     {$ENDC}
  1592. PROCEDURE DisposeCCursor(cCrsr: CCrsrHandle);
  1593.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1594.     INLINE $AA26;
  1595.     {$ENDC}
  1596. {$IFC OLDROUTINELOCATIONS }
  1597. FUNCTION GetCIcon(iconID: INTEGER): CIconHandle;
  1598.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1599.     INLINE $AA1E;
  1600.     {$ENDC}
  1601. PROCEDURE PlotCIcon({CONST}VAR theRect: Rect; theIcon: CIconHandle);
  1602.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1603.     INLINE $AA1F;
  1604.     {$ENDC}
  1605. PROCEDURE DisposeCIcon(theIcon: CIconHandle);
  1606.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1607.     INLINE $AA25;
  1608.     {$ENDC}
  1609. {$ENDC}  {OLDROUTINELOCATIONS}
  1610.  
  1611. PROCEDURE SetStdCProcs(VAR procs: CQDProcs);
  1612.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1613.     INLINE $AA4E;
  1614.     {$ENDC}
  1615. FUNCTION GetMaxDevice({CONST}VAR globalRect: Rect): GDHandle;
  1616.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1617.     INLINE $AA27;
  1618.     {$ENDC}
  1619. FUNCTION GetCTSeed: LONGINT;
  1620.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1621.     INLINE $AA28;
  1622.     {$ENDC}
  1623. FUNCTION GetDeviceList: GDHandle;
  1624.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1625.     INLINE $AA29;
  1626.     {$ENDC}
  1627. FUNCTION GetMainDevice: GDHandle;
  1628.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1629.     INLINE $AA2A;
  1630.     {$ENDC}
  1631. FUNCTION GetNextDevice(curDevice: GDHandle): GDHandle;
  1632.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1633.     INLINE $AA2B;
  1634.     {$ENDC}
  1635. FUNCTION TestDeviceAttribute(gdh: GDHandle; attribute: INTEGER): BOOLEAN;
  1636.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1637.     INLINE $AA2C;
  1638.     {$ENDC}
  1639. PROCEDURE SetDeviceAttribute(gdh: GDHandle; attribute: INTEGER; value: BOOLEAN);
  1640.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1641.     INLINE $AA2D;
  1642.     {$ENDC}
  1643. PROCEDURE InitGDevice(qdRefNum: INTEGER; mode: LONGINT; gdh: GDHandle);
  1644.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1645.     INLINE $AA2E;
  1646.     {$ENDC}
  1647. FUNCTION NewGDevice(refNum: INTEGER; mode: LONGINT): GDHandle;
  1648.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1649.     INLINE $AA2F;
  1650.     {$ENDC}
  1651. PROCEDURE DisposeGDevice(gdh: GDHandle);
  1652.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1653.     INLINE $AA30;
  1654.     {$ENDC}
  1655. PROCEDURE SetGDevice(gd: GDHandle);
  1656.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1657.     INLINE $AA31;
  1658.     {$ENDC}
  1659. FUNCTION GetGDevice: GDHandle;
  1660.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1661.     INLINE $AA32;
  1662.     {$ENDC}
  1663. FUNCTION Color2Index({CONST}VAR myColor: RGBColor): LONGINT;
  1664.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1665.     INLINE $AA33;
  1666.     {$ENDC}
  1667. PROCEDURE Index2Color(index: LONGINT; VAR aColor: RGBColor);
  1668.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1669.     INLINE $AA34;
  1670.     {$ENDC}
  1671. PROCEDURE InvertColor(VAR myColor: RGBColor);
  1672.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1673.     INLINE $AA35;
  1674.     {$ENDC}
  1675. FUNCTION RealColor({CONST}VAR color: RGBColor): BOOLEAN;
  1676.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1677.     INLINE $AA36;
  1678.     {$ENDC}
  1679. PROCEDURE GetSubTable(myColors: CTabHandle; iTabRes: INTEGER; targetTbl: CTabHandle);
  1680.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1681.     INLINE $AA37;
  1682.     {$ENDC}
  1683. PROCEDURE MakeITable(cTabH: CTabHandle; iTabH: ITabHandle; res: INTEGER);
  1684.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1685.     INLINE $AA39;
  1686.     {$ENDC}
  1687. PROCEDURE AddSearch(searchProc: ColorSearchUPP);
  1688.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1689.     INLINE $AA3A;
  1690.     {$ENDC}
  1691. PROCEDURE AddComp(compProc: ColorComplementUPP);
  1692.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1693.     INLINE $AA3B;
  1694.     {$ENDC}
  1695. PROCEDURE DelSearch(searchProc: ColorSearchUPP);
  1696.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1697.     INLINE $AA4C;
  1698.     {$ENDC}
  1699. PROCEDURE DelComp(compProc: ColorComplementUPP);
  1700.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1701.     INLINE $AA4D;
  1702.     {$ENDC}
  1703. PROCEDURE SetClientID(id: INTEGER);
  1704.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1705.     INLINE $AA3C;
  1706.     {$ENDC}
  1707. PROCEDURE ProtectEntry(index: INTEGER; protect: BOOLEAN);
  1708.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1709.     INLINE $AA3D;
  1710.     {$ENDC}
  1711. PROCEDURE ReserveEntry(index: INTEGER; reserve: BOOLEAN);
  1712.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1713.     INLINE $AA3E;
  1714.     {$ENDC}
  1715. PROCEDURE SetEntries(start: INTEGER; count: INTEGER; VAR aTable: CSpecArray);
  1716.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1717.     INLINE $AA3F;
  1718.     {$ENDC}
  1719. PROCEDURE SaveEntries(srcTable: CTabHandle; resultTable: CTabHandle; VAR selection: ReqListRec);
  1720.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1721.     INLINE $AA49;
  1722.     {$ENDC}
  1723. PROCEDURE RestoreEntries(srcTable: CTabHandle; dstTable: CTabHandle; VAR selection: ReqListRec);
  1724.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1725.     INLINE $AA4A;
  1726.     {$ENDC}
  1727. FUNCTION QDError: INTEGER;
  1728.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1729.     INLINE $AA40;
  1730.     {$ENDC}
  1731. PROCEDURE CopyDeepMask({CONST}VAR srcBits: BitMap; {CONST}VAR maskBits: BitMap; {CONST}VAR dstBits: BitMap; {CONST}VAR srcRect: Rect; {CONST}VAR maskRect: Rect; {CONST}VAR dstRect: Rect; mode: INTEGER; maskRgn: RgnHandle);
  1732.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1733.     INLINE $AA51;
  1734.     {$ENDC}
  1735. PROCEDURE DeviceLoop(drawingRgn: RgnHandle; drawingProc: DeviceLoopDrawingUPP; userData: LONGINT; flags: DeviceLoopFlags);
  1736.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1737.     INLINE $ABCA;
  1738.     {$ENDC}
  1739.  
  1740. FUNCTION GetMaskTable: Ptr;
  1741.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1742.     INLINE $A836, $2E88;
  1743.     {$ENDC}
  1744. FUNCTION GetPattern(patternID: INTEGER): PatHandle;
  1745.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1746.     INLINE $A9B8;
  1747.     {$ENDC}
  1748. FUNCTION GetCursor(cursorID: INTEGER): CursHandle;
  1749.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1750.     INLINE $A9B9;
  1751.     {$ENDC}
  1752. FUNCTION GetPicture(pictureID: INTEGER): PicHandle;
  1753.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1754.     INLINE $A9BC;
  1755.     {$ENDC}
  1756. FUNCTION DeltaPoint(ptA: Point; ptB: Point): LONGINT;
  1757.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1758.     INLINE $A94F;
  1759.     {$ENDC}
  1760. PROCEDURE ShieldCursor({CONST}VAR shieldRect: Rect; offsetPt: Point);
  1761.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1762.     INLINE $A855;
  1763.     {$ENDC}
  1764. PROCEDURE ScreenRes(VAR scrnHRes: INTEGER; VAR scrnVRes: INTEGER);
  1765.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1766.     INLINE $225F, $32B8, $0102, $225F, $32B8, $0104;
  1767.     {$ENDC}
  1768. PROCEDURE GetIndPattern(VAR thePat: Pattern; patternListID: INTEGER; index: INTEGER);
  1769.  
  1770. {$IFC OLDROUTINENAMES }
  1771. PROCEDURE DisposPixMap(pm: PixMapHandle);
  1772.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1773.     INLINE $AA04;
  1774.     {$ENDC}
  1775. PROCEDURE DisposPixPat(pp: PixPatHandle);
  1776.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1777.     INLINE $AA08;
  1778.     {$ENDC}
  1779. PROCEDURE DisposCTable(cTable: CTabHandle);
  1780.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1781.     INLINE $AA24;
  1782.     {$ENDC}
  1783. PROCEDURE DisposCCursor(cCrsr: CCrsrHandle);
  1784.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1785.     INLINE $AA26;
  1786.     {$ENDC}
  1787. {$IFC OLDROUTINELOCATIONS }
  1788. PROCEDURE DisposCIcon(theIcon: CIconHandle);
  1789.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1790.     INLINE $AA25;
  1791.     {$ENDC}
  1792. {$ENDC}
  1793. PROCEDURE DisposGDevice(gdh: GDHandle);
  1794.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1795.     INLINE $AA30;
  1796.     {$ENDC}
  1797. {$IFC OLDROUTINELOCATIONS }
  1798. {$ENDC}
  1799. {$ENDC}  {OLDROUTINENAMES}
  1800.  
  1801. {
  1802.     From ToolUtils.i
  1803. }
  1804. PROCEDURE PackBits(VAR srcPtr: Ptr; VAR dstPtr: Ptr; srcBytes: INTEGER);
  1805.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1806.     INLINE $A8CF;
  1807.     {$ENDC}
  1808. PROCEDURE UnpackBits(VAR srcPtr: Ptr; VAR dstPtr: Ptr; dstBytes: INTEGER);
  1809.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1810.     INLINE $A8D0;
  1811.     {$ENDC}
  1812.  
  1813. {
  1814.     Also from ToolUtils.i
  1815. }
  1816. FUNCTION SlopeFromAngle(angle: INTEGER): Fixed;
  1817.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1818.     INLINE $A8BC;
  1819.     {$ENDC}
  1820. FUNCTION AngleFromSlope(slope: Fixed): INTEGER;
  1821.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1822.     INLINE $A8C4;
  1823.     {$ENDC}
  1824.  
  1825.  
  1826.  
  1827.  
  1828.  
  1829.  
  1830.  
  1831. {----------------------------PICT • Quickdraw Picture----------------------------------}
  1832.  
  1833.  
  1834.  
  1835.  
  1836.  
  1837. {$ALIGN RESET}
  1838. {$POP}
  1839.  
  1840. {$SETC UsingIncludes := QuickdrawIncludes}
  1841.  
  1842. {$ENDC} {__QUICKDRAW__}
  1843.  
  1844. {$IFC NOT UsingIncludes}
  1845.  END.
  1846. {$ENDC}
  1847.